home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / mint / lib / mntlib44.zoo / mntlib / a64l.c < prev    next >
C/C++ Source or Header  |  1994-03-01  |  3KB  |  114 lines
  1. /****************************************************************/
  2. /* Module name:   a64l.c                                        */
  3. /* Library name:  mintlibs for Atari ST                         */
  4. /* Author:        Hildo Biersma (boender@dutiws.twi.tudelft.nl) */
  5. /* Date:          January 11, 1993                              */
  6. /* Revision:      1 (first attempt)                             */
  7. /*                2 ++entropy Made compatible with K&R compilers*/
  8. /****************************************************************/
  9.  
  10. /* FIXME: maybe use ERANGE or EDOM instead of EBADARG */
  11.  
  12. /*
  13. NAME
  14.     a64l, l64a - convert between long integer and base-64 ASCII string
  15.  
  16. SYNOPSIS
  17.     #include <support.h>
  18.     long a64l(const char *s);
  19.     char *l64a(long l);
  20.  
  21. DESCRIPTION
  22.     These functions are used to maintain numbers stored in base-64
  23.     ASCII characters. This is a notation by which long integers
  24.     can be represented by up to six characters; each character
  25.     represents a "digit" in a radix-64 notation.
  26.     
  27.     The characters used to represent "digits" are . for 0, / for 1,
  28.     0 through 9 for 2-11, A through Z for 12-37, and a through z
  29.     for 38-63.
  30.     
  31.     a64l takes a pointer to a null-terminated base-64 representation
  32.     and returns a corresponding long value. If the string pointed to
  33.     by s contains more than six characters, a64l will use the first
  34.     six. a64l scans the character string from left to right, decoding
  35.     each character as a 6 bit radix-64 number. If the string contains
  36.     illegal characters, -1 is returned and errno is set to EBADARG.
  37.     
  38.     l64a takes a long argument and returns a pointer to the
  39.     corresponding base-64 representation. If the argument is 0, a64l
  40.     returns a pointer to a null string. If the argument is smaller
  41.     than zero, a pointer to a null string is returned and errno is
  42.     set to EBADARG.
  43.  
  44. CAVEATS
  45.     The value returned by l64a is a pointer into a static buffer,
  46.     the contents of which are overwritten by each call.
  47.     
  48.     The value returned by a64l may be incorrect if the value
  49.     is too large; for that reason, only strings that resulted
  50.     from a call to l64a should be used to call a64l.
  51.  
  52.     Maybe these calls should unsigned long values, but longs are
  53.     used here to retain compatibility with UN*X System V.
  54.  
  55. AUTHOR
  56.     Hildo Biersma, with the help of a UN*X System V man page.
  57. */
  58.  
  59. #include <support.h>
  60. #include <errno.h>
  61. extern int errno;
  62.  
  63. #ifndef _COMPILER_H
  64. #include <compiler.h>
  65. #endif
  66.  
  67. /* Local function prototypes */
  68. static int a64i __PROTO((char c));  /* base-64 char to int, -1 on error */
  69.  
  70. /* base-64 char to int, -1 on error */
  71. static int a64i(c)
  72.   char c;
  73. {
  74.   int retval = c;
  75.  
  76.   if ((c < '.') || (c > 'z'))
  77.   {
  78.     errno = EBADARG;
  79.     return(-1);
  80.   }
  81.   retval -= '.';
  82.   if (c > '9')
  83.     retval -= 'A' - '9' - 1;
  84.   if (c > 'Z')
  85.     retval -= 'a' - 'Z' - 1;
  86.   if (retval > 63)
  87.   {
  88.     errno = EBADARG;
  89.     return(-1);
  90.   }
  91.   return(retval);
  92. } /* End of a64i() */
  93.  
  94. /* base-64 string to long */
  95. long a64l(s)
  96.   const char *s;
  97. {
  98.   long retval = 0;
  99.   int counter = 0;
  100.   const char *ptr = s;
  101.  
  102.   while ((counter++ < 6) && (*ptr != 0x00))
  103.   {
  104.     int val;
  105.     
  106.     if ((val = a64i(*ptr++)) == -1)
  107.       return(-1); /* errno was set by a64i() */
  108.     retval <<= 6;
  109.     retval += val;
  110.   }
  111.   return(retval);
  112. } /* End of a64l() */
  113.  
  114.